home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / front.lha / front / m2c / Parser.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  40KB  |  1,193 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Scanner
  4. #include "Scanner.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_Positions
  8. #include "Positions.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Errors
  12. #include "Errors.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Strings
  16. #include "Strings.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_DynArray
  20. #include "DynArray.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Sets
  24. #include "Sets.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_System
  28. #include "System.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Actions
  32. #include "Actions.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Errors
  36. #include "Errors.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Lists
  40. #include "Lists.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Oper
  44. #include "Oper.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_Scanner
  48. #include "Scanner.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_Positions
  52. #include "Positions.h"
  53. #endif
  54.  
  55. #ifndef DEFINITION_Strings
  56. #include "Strings.h"
  57. #endif
  58.  
  59. #ifndef DEFINITION_StringMem
  60. #include "StringMem.h"
  61. #endif
  62.  
  63. #ifndef DEFINITION_Idents
  64. #include "Idents.h"
  65. #endif
  66.  
  67. #ifndef DEFINITION_TokenTab
  68. #include "TokenTab.h"
  69. #endif
  70.  
  71. #ifndef DEFINITION_Tokens
  72. #include "Tokens.h"
  73. #endif
  74.  
  75. #ifndef DEFINITION_Rules
  76. #include "Rules.h"
  77. #endif
  78.  
  79. #ifndef DEFINITION_Parser
  80. #include "Parser.h"
  81. #endif
  82.  
  83. struct Parser_1 Parser_ParsTabName;
  84.  
  85. #define cEol    '\n'
  86. #define eNumToBig    9
  87. typedef struct S_1 {
  88.     Scanner_tScanAttribute Scan;
  89. } tParsAttribute;
  90. static Strings_tString String, EndOfLineString;
  91. static ADDRESS EndOfLine;
  92. #define yyInitStackSize    100
  93. #define yyNoState    0
  94. #define yyFirstTerminal    0
  95. #define yyLastTerminal    30
  96. #define yyFirstSymbol    0
  97. #define yyLastSymbol    62
  98. #define yyTableMax    222
  99. #define yyNTableMax    131
  100. #define yyFirstReadState    1
  101. #define yyLastReadState    62
  102. #define yyFirstReadTermState    63
  103. #define yyLastReadTermState    78
  104. #define yyLastReadNontermState    96
  105. #define yyFirstReduceState    97
  106. #define yyLastReduceState    159
  107. #define yyStartState    1
  108. #define yyStopState    97
  109. #define yyFirstFinalState    yyFirstReadTermState
  110. #define yyLastState    yyLastReduceState
  111. typedef SHORTCARD yyTableElmt;
  112. typedef yyTableElmt yyTCombRange;
  113. typedef yyTableElmt yyNCombRange;
  114. typedef yyTableElmt yyStateRange;
  115. typedef yyTableElmt yyReadRange;
  116. typedef yyTableElmt yyReadReduceRange;
  117. typedef yyTableElmt yyReduceRange;
  118. typedef yyTableElmt yySymbolRange;
  119. typedef struct S_2 {
  120.     yyStateRange Check, Next;
  121. } yyTCombType;
  122. typedef yyStateRange yyNCombType;
  123. typedef yyTCombType *yyTCombTypePtr;
  124. typedef yyNCombType *yyNCombTypePtr;
  125. typedef struct S_3 {
  126.     yyStateRange A[1000000 + 1];
  127. } *yyStackType;
  128. static struct S_4 {
  129.     yyTCombTypePtr A[yyLastReadState + 1];
  130. } yyTBasePtr;
  131. static struct S_5 {
  132.     yyNCombTypePtr A[yyLastReadState + 1];
  133. } yyNBasePtr;
  134. static struct S_6 {
  135.     yyReadRange A[yyLastReadState + 1];
  136. } yyDefault;
  137. static struct S_7 {
  138.     yyTCombType A[yyTableMax + 1];
  139. } yyTComb;
  140. static struct S_8 {
  141.     yyNCombType A[yyNTableMax - (yyLastTerminal + 1) + 1];
  142. } yyNComb;
  143. static struct S_9 {
  144.     yyTableElmt A[yyLastReduceState - yyFirstReduceState + 1];
  145. } yyLength;
  146. static struct S_10 {
  147.     yySymbolRange A[yyLastReduceState - yyFirstReduceState + 1];
  148. } yyLeftHandSide;
  149. static struct S_11 {
  150.     yySymbolRange A[yyLastReadState + 1];
  151. } yyContinuation;
  152. static struct S_12 {
  153.     yyReduceRange A[yyLastReadNontermState - yyFirstReadTermState + 1];
  154. } yyFinalToProd;
  155. static BOOLEAN yyIsInitialized;
  156. static System_tFile yyTableFile;
  157. static void Copy ARGS((CHAR Source[], LONGCARD , CHAR Target[], LONGCARD ));
  158. struct S_16 {
  159.     tParsAttribute A[1000000 + 1];
  160. };
  161. struct S_17 {
  162.     CHAR A[127 + 1];
  163. };
  164. static void ErrorRecovery ARGS((yySymbolRange *Terminal, yyStackType StateStack, LONGINT StackSize, LONGINT StackPtr));
  165. struct S_18 {
  166.     CHAR A[127 + 1];
  167. };
  168. static void ComputeContinuation ARGS((yyStackType Stack, LONGINT StackSize, LONGINT StackPtr, Sets_tSet *ContinueSet));
  169. static BOOLEAN IsContinuation ARGS((yySymbolRange Terminal, yyStackType ParseStack, LONGINT StackSize, LONGINT StackPtr));
  170. static void ComputeRestartPoints ARGS((yyStackType ParseStack, LONGINT StackSize, LONGINT StackPtr, Sets_tSet *RestartSet));
  171. static yyStateRange Next ARGS((yyStateRange State, yySymbolRange Symbol));
  172. static void yyGetTables ARGS(());
  173. struct S_19 {
  174.     yyTCombRange A[yyLastReadState + 1];
  175. };
  176. struct S_20 {
  177.     yyNCombRange A[yyLastReadState + 1];
  178. };
  179. static CARDINAL yyGetTable ARGS((ADDRESS Address));
  180. static void yyErrorCheck ARGS((INTEGER ErrorCode, INTEGER Info));
  181. static void BeginParser ARGS(());
  182.  
  183.  
  184. static void Copy
  185. # ifdef __STDC__
  186. (CHAR Source[], LONGCARD O_2, CHAR Target[], LONGCARD O_1)
  187. # else
  188. (Source, O_2, Target, O_1)
  189. CHAR Source[];
  190. LONGCARD O_2;
  191. CHAR Target[];
  192. LONGCARD O_1;
  193. # endif
  194. {
  195.   CARDINAL i, j;
  196.   OPEN_ARRAY_LOCALS
  197.  
  198.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(CHAR), 1)
  199.   COPY_OPEN_ARRAY(Source, O_2, CHAR)
  200.   if ((O_2 - 1) < (O_1 - 1)) {
  201.     j = (O_2 - 1);
  202.   } else {
  203.     j = (O_1 - 1);
  204.   }
  205.   {
  206.     LONGCARD B_1 = 0, B_2 = j;
  207.  
  208.     if (B_1 <= B_2)
  209.       for (i = B_1;; i += 1) {
  210.         Target[i] = Source[i];
  211.         if (i >= B_2) break;
  212.       }
  213.   }
  214.   if ((O_1 - 1) > j) {
  215.     Target[j + 1] = CHR(0);
  216.   }
  217.   FREE_OPEN_ARRAYS
  218. }
  219.  
  220. void Parser_TokenName
  221. # ifdef __STDC__
  222. (CARDINAL Token, CHAR Name[], LONGCARD O_3)
  223. # else
  224. (Token, Name, O_3)
  225. CARDINAL Token;
  226. CHAR Name[];
  227. LONGCARD O_3;
  228. # endif
  229. {
  230.   switch (Token) {
  231.   case 0:;
  232.     Copy((STRING)"_EndOfFile", 10L, Name, O_3);
  233.     break;
  234.   case 1:;
  235.     Copy((STRING)"=", 1L, Name, O_3);
  236.     break;
  237.   case 2:;
  238.     Copy((STRING)":", 1L, Name, O_3);
  239.     break;
  240.   case 3:;
  241.     Copy((STRING)".", 1L, Name, O_3);
  242.     break;
  243.   case 4:;
  244.     Copy((STRING)"|", 1L, Name, O_3);
  245.     break;
  246.   case 5:;
  247.     Copy((STRING)"*", 1L, Name, O_3);
  248.     break;
  249.   case 6:;
  250.     Copy((STRING)"+", 1L, Name, O_3);
  251.     break;
  252.   case 7:;
  253.     Copy((STRING)"||", 2L, Name, O_3);
  254.     break;
  255.   case 8:;
  256.     Copy((STRING)"(", 1L, Name, O_3);
  257.     break;
  258.   case 9:;
  259.     Copy((STRING)")", 1L, Name, O_3);
  260.     break;
  261.   case 10:;
  262.     Copy((STRING)"[", 1L, Name, O_3);
  263.     break;
  264.   case 11:;
  265.     Copy((STRING)"]", 1L, Name, O_3);
  266.     break;
  267.   case 12:;
  268.     Copy((STRING)"EXPORT", 6L, Name, O_3);
  269.     break;
  270.   case 13:;
  271.     Copy((STRING)"GLOBAL", 6L, Name, O_3);
  272.     break;
  273.   case 14:;
  274.     Copy((STRING)"LOCAL", 5L, Name, O_3);
  275.     break;
  276.   case 15:;
  277.     Copy((STRING)"BEGIN", 5L, Name, O_3);
  278.     break;
  279.   case 16:;
  280.     Copy((STRING)"CLOSE", 5L, Name, O_3);
  281.     break;
  282.   case 17:;
  283.     Copy((STRING)"TOKEN", 5L, Name, O_3);
  284.     break;
  285.   case 18:;
  286.     Copy((STRING)"OPER", 4L, Name, O_3);
  287.     break;
  288.   case 19:;
  289.     Copy((STRING)"NONE", 4L, Name, O_3);
  290.     break;
  291.   case 20:;
  292.     Copy((STRING)"LEFT", 4L, Name, O_3);
  293.     break;
  294.   case 21:;
  295.     Copy((STRING)"RIGHT", 5L, Name, O_3);
  296.     break;
  297.   case 22:;
  298.     Copy((STRING)"RULE", 4L, Name, O_3);
  299.     break;
  300.   case 23:;
  301.     Copy((STRING)"PREC", 4L, Name, O_3);
  302.     break;
  303.   case 24:;
  304.     Copy((STRING)"Comment", 7L, Name, O_3);
  305.     break;
  306.   case 25:;
  307.     Copy((STRING)"Number", 6L, Name, O_3);
  308.     break;
  309.   case 26:;
  310.     Copy((STRING)"Action", 6L, Name, O_3);
  311.     break;
  312.   case 27:;
  313.     Copy((STRING)"Identifier", 10L, Name, O_3);
  314.     break;
  315.   case 28:;
  316.     Copy((STRING)"String", 6L, Name, O_3);
  317.     break;
  318.   case 29:;
  319.     Copy((STRING)"SCANNER", 7L, Name, O_3);
  320.     break;
  321.   case 30:;
  322.     Copy((STRING)"PARSER", 6L, Name, O_3);
  323.     break;
  324.   }
  325. }
  326.  
  327. CARDINAL Parser_Parser
  328. # ifdef __STDC__
  329. ()
  330. # else
  331. ()
  332. # endif
  333. {
  334.   Actions_tActionMode ActionMode;
  335.   yyStateRange yyState;
  336.   yySymbolRange yyTerminal;
  337.   yySymbolRange yyNonterminal;
  338.   yyTableElmt yyStackPtr;
  339.   LONGINT yyStateStackSize;
  340.   LONGINT yyAttrStackSize;
  341.   yyTableElmt yyShortStackSize;
  342.   yyStackType yyStateStack;
  343.   struct S_16 *yyAttributeStack;
  344.   tParsAttribute yySynAttribute;
  345.   Scanner_tScanAttribute yyRepairAttribute;
  346.   yySymbolRange yyRepairToken;
  347.   yyTCombTypePtr yyTCombPtr;
  348.   yyNCombTypePtr yyNCombPtr;
  349.   BOOLEAN yyIsRepairing;
  350.   CARDINAL yyErrorCount;
  351.   struct S_17 yyTokenString;
  352.  
  353.   BeginParser();
  354.   yyState = yyStartState;
  355.   yyTerminal = Scanner_GetToken();
  356.   yyStateStackSize = yyInitStackSize;
  357.   yyAttrStackSize = yyInitStackSize;
  358.   DynArray_MakeArray((ADDRESS *)&yyStateStack, &yyStateStackSize, (LONGINT)sizeof(yyStateRange));
  359.   DynArray_MakeArray((ADDRESS *)&yyAttributeStack, &yyAttrStackSize, (LONGINT)sizeof(tParsAttribute));
  360.   yyShortStackSize = yyStateStackSize - 1;
  361.   yyStackPtr = 0;
  362.   yyErrorCount = 0;
  363.   yyIsRepairing = FALSE;
  364.   for (;;) {
  365.     if (yyStackPtr >= yyShortStackSize) {
  366.       DynArray_ExtendArray((ADDRESS *)&yyStateStack, &yyStateStackSize, (LONGINT)sizeof(yyStateRange));
  367.       DynArray_ExtendArray((ADDRESS *)&yyAttributeStack, &yyAttrStackSize, (LONGINT)sizeof(tParsAttribute));
  368.       yyShortStackSize = yyStateStackSize - 1;
  369.     }
  370.     yyStateStack->A[yyStackPtr] = yyState;
  371.     for (;;) {
  372.       yyTCombPtr = (yyTCombTypePtr)((LONGCARD)yyTBasePtr.A[yyState] + yyTerminal * sizeof(yyTCombType));
  373.       if (yyTCombPtr->Check == yyState) {
  374.         yyState = yyTCombPtr->Next;
  375.         goto EXIT_2;
  376.       }
  377.       yyState = yyDefault.A[yyState];
  378.       if (yyState == yyNoState) {
  379.         yyState = yyStateStack->A[yyStackPtr];
  380.         if (yyIsRepairing) {
  381.           yyRepairToken = yyContinuation.A[yyState];
  382.           yyState = Next(yyState, yyRepairToken);
  383.           if (yyState <= yyLastReadTermState) {
  384.             Scanner_ErrorAttribute((LONGINT)yyRepairToken, &yyRepairAttribute);
  385.             Parser_TokenName((LONGCARD)yyRepairToken, yyTokenString.A, 128L);
  386.             Errors_ErrorMessageI((LONGCARD)Errors_TokenInserted, (LONGCARD)Errors_Repair, Scanner_Attribute.Position, (LONGCARD)Errors_Array, ADR(yyTokenString));
  387.             if (yyState >= yyFirstFinalState) {
  388.               yyState = yyFinalToProd.A[yyState - 63];
  389.             }
  390.             INC(yyStackPtr);
  391.             yyAttributeStack->A[yyStackPtr].Scan = yyRepairAttribute;
  392.             yyStateStack->A[yyStackPtr] = yyState;
  393.           }
  394.           if (yyState >= yyFirstFinalState) {
  395.             goto EXIT_2;
  396.           }
  397.         } else {
  398.           INC(yyErrorCount);
  399.           ErrorRecovery(&yyTerminal, yyStateStack, yyStateStackSize, (LONGINT)yyStackPtr);
  400.           yyIsRepairing = TRUE;
  401.         }
  402.       }
  403.     } EXIT_2:;
  404.     if (yyState >= yyFirstFinalState) {
  405.       if (yyState <= yyLastReadTermState) {
  406.         INC(yyStackPtr);
  407.         yyAttributeStack->A[yyStackPtr].Scan = Scanner_Attribute;
  408.         yyTerminal = Scanner_GetToken();
  409.         yyIsRepairing = FALSE;
  410.       }
  411.       for (;;) {
  412.         switch (yyState) {
  413.         case 97:;
  414.           DynArray_ReleaseArray((ADDRESS *)&yyStateStack, &yyStateStackSize, (LONGINT)sizeof(yyTableElmt));
  415.           DynArray_ReleaseArray((ADDRESS *)&yyAttributeStack, &yyAttrStackSize, (LONGINT)sizeof(tParsAttribute));
  416.           return yyErrorCount;
  417.           break;
  418.         case 98:;
  419.         case 96:;
  420.           DEC1(yyStackPtr, 7);
  421.           yyNonterminal = 38;
  422.           Tokens_MakeGlobalHeader(yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_1.Comm, yyAttributeStack->A[yyStackPtr + 1].Scan.Position);
  423.           break;
  424.         case 99:;
  425.           DEC1(yyStackPtr, 0);
  426.           yyNonterminal = 32;
  427.           Actions_ScannerName = Idents_NoIdent;
  428.           break;
  429.         case 100:;
  430.           DEC1(yyStackPtr, 1);
  431.           yyNonterminal = 32;
  432.           Strings_ArrayToString((STRING)"Scanner", 7L, &String);
  433.           Actions_ScannerName = Idents_MakeIdent(&String);
  434.           break;
  435.         case 101:;
  436.         case 64:;
  437.           DEC1(yyStackPtr, 2);
  438.           yyNonterminal = 32;
  439.           Actions_ScannerName = yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_4.Sym;
  440.           break;
  441.         case 102:;
  442.           DEC1(yyStackPtr, 0);
  443.           yyNonterminal = 33;
  444.           Actions_ParserName = Idents_NoIdent;
  445.           break;
  446.         case 103:;
  447.           DEC1(yyStackPtr, 1);
  448.           yyNonterminal = 33;
  449.           Strings_ArrayToString((STRING)"Parser", 6L, &String);
  450.           Actions_ParserName = Idents_MakeIdent(&String);
  451.           break;
  452.         case 104:;
  453.         case 65:;
  454.           DEC1(yyStackPtr, 2);
  455.           yyNonterminal = 33;
  456.           Actions_ParserName = yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_4.Sym;
  457.           break;
  458.         case 105:;
  459.         case 79:;
  460.           DEC1(yyStackPtr, 5);
  461.           yyNonterminal = 34;
  462.           Actions_PutComment(Actions_Export, yyAttributeStack->A[yyStackPtr + 2].Scan.Position, yyAttributeStack->A[yyStackPtr + 4].Scan.U_1.V_1.Comm, yyAttributeStack->A[yyStackPtr + 4].Scan.Position);
  463.           break;
  464.         case 106:;
  465.         case 80:;
  466.           DEC1(yyStackPtr, 5);
  467.           yyNonterminal = 34;
  468.           Actions_PutComment(Actions_Global, yyAttributeStack->A[yyStackPtr + 2].Scan.Position, yyAttributeStack->A[yyStackPtr + 4].Scan.U_1.V_1.Comm, yyAttributeStack->A[yyStackPtr + 4].Scan.Position);
  469.           break;
  470.         case 107:;
  471.         case 81:;
  472.           DEC1(yyStackPtr, 5);
  473.           yyNonterminal = 34;
  474.           Actions_PutComment(Actions_Local, yyAttributeStack->A[yyStackPtr + 2].Scan.Position, yyAttributeStack->A[yyStackPtr + 4].Scan.U_1.V_1.Comm, yyAttributeStack->A[yyStackPtr + 4].Scan.Position);
  475.           break;
  476.         case 108:;
  477.         case 82:;
  478.           DEC1(yyStackPtr, 5);
  479.           yyNonterminal = 34;
  480.           Actions_PutComment(Actions_Begin, yyAttributeStack->A[yyStackPtr + 2].Scan.Position, yyAttributeStack->A[yyStackPtr + 4].Scan.U_1.V_1.Comm, yyAttributeStack->A[yyStackPtr + 4].Scan.Position);
  481.           break;
  482.         case 109:;
  483.         case 83:;
  484.           DEC1(yyStackPtr, 5);
  485.           yyNonterminal = 34;
  486.           Actions_PutComment(Actions_Close, yyAttributeStack->A[yyStackPtr + 2].Scan.Position, yyAttributeStack->A[yyStackPtr + 4].Scan.U_1.V_1.Comm, yyAttributeStack->A[yyStackPtr + 4].Scan.Position);
  487.           break;
  488.         case 110:;
  489.           DEC1(yyStackPtr, 0);
  490.           yyNonterminal = 34;
  491.           break;
  492.         case 111:;
  493.           DEC1(yyStackPtr, 0);
  494.           yyNonterminal = 44;
  495.           ActionMode = Actions_Close;
  496.           break;
  497.         case 112:;
  498.           DEC1(yyStackPtr, 0);
  499.           yyNonterminal = 43;
  500.           ActionMode = Actions_Begin;
  501.           break;
  502.         case 113:;
  503.           DEC1(yyStackPtr, 0);
  504.           yyNonterminal = 42;
  505.           ActionMode = Actions_Local;
  506.           break;
  507.         case 114:;
  508.           DEC1(yyStackPtr, 0);
  509.           yyNonterminal = 41;
  510.           ActionMode = Actions_Global;
  511.           break;
  512.         case 115:;
  513.           DEC1(yyStackPtr, 0);
  514.           yyNonterminal = 39;
  515.           ActionMode = Actions_Export;
  516.           break;
  517.         case 116:;
  518.           DEC1(yyStackPtr, 2);
  519.           yyNonterminal = 40;
  520.           Actions_PutAction(ActionMode, yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_3.Act, yyAttributeStack->A[yyStackPtr + 1].Scan.Position, yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_1.Comm, yyAttributeStack->A[yyStackPtr + 2].Scan.Position);
  521.           break;
  522.         case 117:;
  523.           DEC1(yyStackPtr, 0);
  524.           yyNonterminal = 40;
  525.           break;
  526.         case 118:;
  527.           DEC1(yyStackPtr, 3);
  528.           yyNonterminal = 35;
  529.           Tokens_CompleteDeclarations();
  530.           Tokens_MakeTokensHeader(yyAttributeStack->A[yyStackPtr + 1].Scan.Position, yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_1.Comm, yyAttributeStack->A[yyStackPtr + 2].Scan.Position);
  531.           break;
  532.         case 119:;
  533.         case 84:;
  534.           DEC1(yyStackPtr, 2);
  535.           yyNonterminal = 45;
  536.           break;
  537.         case 120:;
  538.         case 85:;
  539.           DEC1(yyStackPtr, 1);
  540.           yyNonterminal = 45;
  541.           break;
  542.         case 121:;
  543.           DEC1(yyStackPtr, 3);
  544.           yyNonterminal = 46;
  545.           Tokens_MakeDeclaration(yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_4.Sym, yyAttributeStack->A[yyStackPtr + 1].Scan.Position, yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_5.HasCoding, yyAttributeStack->A[yyStackPtr + 2].Scan.Position, (TokenTab_Terminal)yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_5.CodValue, yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_5.CodNumbPos, yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_1.Comm, yyAttributeStack->A[yyStackPtr + 3].Scan.Position);
  546.           break;
  547.         case 122:;
  548.         case 68:;
  549.           DEC1(yyStackPtr, 2);
  550.           yyNonterminal = 48;
  551.           yySynAttribute.Scan.Mode = Scanner_Coding;
  552.           if (yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_2.Value > 1000) {
  553.             Errors_ErrorMessageI((LONGCARD)eNumToBig, (LONGCARD)Errors_eError, yyAttributeStack->A[yyStackPtr + 2].Scan.Position, (LONGCARD)Errors_eInteger, ADR(yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_2.Value));
  554.             yySynAttribute.Scan.U_1.V_5.HasCoding = FALSE;
  555.             yySynAttribute.Scan.U_1.V_5.CodValue = 0;
  556.             yySynAttribute.Scan.U_1.V_5.CodNumbPos = Positions_NoPosition;
  557.           } else {
  558.             yySynAttribute.Scan.U_1.V_5.HasCoding = TRUE;
  559.             yySynAttribute.Scan.U_1.V_5.CodValue = yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_2.Value;
  560.             yySynAttribute.Scan.U_1.V_5.CodNumbPos = yyAttributeStack->A[yyStackPtr + 2].Scan.Position;
  561.           }
  562.           break;
  563.         case 123:;
  564.           DEC1(yyStackPtr, 0);
  565.           yyNonterminal = 48;
  566.           yySynAttribute.Scan.Mode = Scanner_Coding;
  567.           yySynAttribute.Scan.U_1.V_5.HasCoding = FALSE;
  568.           yySynAttribute.Scan.U_1.V_5.CodValue = 0;
  569.           yySynAttribute.Scan.U_1.V_5.CodNumbPos = Positions_NoPosition;
  570.           break;
  571.         case 124:;
  572.         case 86:;
  573.           DEC1(yyStackPtr, 3);
  574.           yyNonterminal = 36;
  575.           Oper_MakeOperHeader(yyAttributeStack->A[yyStackPtr + 1].Scan.Position, yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_1.Comm, yyAttributeStack->A[yyStackPtr + 2].Scan.Position);
  576.           break;
  577.         case 125:;
  578.           DEC1(yyStackPtr, 0);
  579.           yyNonterminal = 36;
  580.           break;
  581.         case 126:;
  582.         case 87:;
  583.           DEC1(yyStackPtr, 2);
  584.           yyNonterminal = 49;
  585.           break;
  586.         case 127:;
  587.           DEC1(yyStackPtr, 0);
  588.           yyNonterminal = 49;
  589.           break;
  590.         case 128:;
  591.           DEC1(yyStackPtr, 3);
  592.           yyNonterminal = 50;
  593.           Oper_CompletePriority(yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_1.Comm, yyAttributeStack->A[yyStackPtr + 3].Scan.Position);
  594.           break;
  595.         case 129:;
  596.         case 70:;
  597.           DEC1(yyStackPtr, 1);
  598.           yyNonterminal = 51;
  599.           Oper_MakePriority(Oper_Left, yyAttributeStack->A[yyStackPtr + 1].Scan.Position);
  600.           break;
  601.         case 130:;
  602.         case 71:;
  603.           DEC1(yyStackPtr, 1);
  604.           yyNonterminal = 51;
  605.           Oper_MakePriority(Oper_Right, yyAttributeStack->A[yyStackPtr + 1].Scan.Position);
  606.           break;
  607.         case 131:;
  608.         case 69:;
  609.           DEC1(yyStackPtr, 1);
  610.           yyNonterminal = 51;
  611.           Oper_MakePriority(Oper_None, yyAttributeStack->A[yyStackPtr + 1].Scan.Position);
  612.           break;
  613.         case 132:;
  614.         case 89:;
  615.           DEC1(yyStackPtr, 2);
  616.           yyNonterminal = 52;
  617.           break;
  618.         case 133:;
  619.           DEC1(yyStackPtr, 1);
  620.           yyNonterminal = 52;
  621.           break;
  622.         case 134:;
  623.         case 88:;
  624.           DEC1(yyStackPtr, 1);
  625.           yyNonterminal = 53;
  626.           Oper_MakeOperator(yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_4.Sym, yyAttributeStack->A[yyStackPtr + 1].Scan.Position);
  627.           break;
  628.         case 135:;
  629.         case 66:;
  630.           DEC1(yyStackPtr, 1);
  631.           yyNonterminal = 47;
  632.           yySynAttribute.Scan.Mode = Scanner_Symbol;
  633.           yySynAttribute.Scan.U_1.V_4.Sym = yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_4.Sym;
  634.           yySynAttribute.Scan.Position = yyAttributeStack->A[yyStackPtr + 1].Scan.Position;
  635.           break;
  636.         case 136:;
  637.         case 67:;
  638.           DEC1(yyStackPtr, 1);
  639.           yyNonterminal = 47;
  640.           yySynAttribute.Scan.Mode = Scanner_Symbol;
  641.           yySynAttribute.Scan.U_1.V_4.Sym = yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_4.Sym;
  642.           yySynAttribute.Scan.Position = yyAttributeStack->A[yyStackPtr + 1].Scan.Position;
  643.           break;
  644.         case 137:;
  645.           DEC1(yyStackPtr, 3);
  646.           yyNonterminal = 37;
  647.           Rules_MakeRulesHeader(yyAttributeStack->A[yyStackPtr + 1].Scan.Position, yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_1.Comm, yyAttributeStack->A[yyStackPtr + 2].Scan.Position);
  648.           break;
  649.         case 138:;
  650.           DEC1(yyStackPtr, 0);
  651.           yyNonterminal = 54;
  652.           break;
  653.         case 139:;
  654.         case 95:;
  655.           DEC1(yyStackPtr, 2);
  656.           yyNonterminal = 54;
  657.           break;
  658.         case 140:;
  659.           DEC1(yyStackPtr, 5);
  660.           yyNonterminal = 55;
  661.           Rules_MakeRule(yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_4.Sym, yyAttributeStack->A[yyStackPtr + 1].Scan.Position, yyAttributeStack->A[yyStackPtr + 2].Scan.Position, yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_6.Expr, yyAttributeStack->A[yyStackPtr + 5].Scan.U_1.V_1.Comm, yyAttributeStack->A[yyStackPtr + 5].Scan.Position, yyAttributeStack->A[yyStackPtr + 4].Scan.Position, yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_6.HasPrio, yyAttributeStack->A[yyStackPtr + 3].Scan.Position, yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_6.U_1.V_1.PriSym, yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_6.U_1.V_1.PriSymPos);
  662.           break;
  663.         case 141:;
  664.         case 93:;
  665.           DEC1(yyStackPtr, 2);
  666.           yyNonterminal = 57;
  667.           yySynAttribute.Scan.Mode = Scanner_PrioPart;
  668.           yySynAttribute.Scan.U_1.V_6.HasPrio = TRUE;
  669.           yySynAttribute.Scan.Position = yyAttributeStack->A[yyStackPtr + 1].Scan.Position;
  670.           yySynAttribute.Scan.U_1.V_6.U_1.V_1.PriSym = yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_4.Sym;
  671.           yySynAttribute.Scan.U_1.V_6.U_1.V_1.PriSymPos = yyAttributeStack->A[yyStackPtr + 2].Scan.Position;
  672.           break;
  673.         case 142:;
  674.           DEC1(yyStackPtr, 0);
  675.           yyNonterminal = 57;
  676.           yySynAttribute.Scan.Mode = Scanner_PrioPart;
  677.           yySynAttribute.Scan.U_1.V_6.HasPrio = FALSE;
  678.           yySynAttribute.Scan.U_1.V_6.U_1.V_1.PriSymPos = Positions_NoPosition;
  679.           yySynAttribute.Scan.U_1.V_6.U_1.V_1.PriSym = 0;
  680.           break;
  681.         case 143:;
  682.         case 94:;
  683.           DEC1(yyStackPtr, 4);
  684.           yyNonterminal = 56;
  685.           yySynAttribute.Scan = yyAttributeStack->A[yyStackPtr + 4].Scan;
  686.           yySynAttribute.Scan.Mode = Scanner_RightSide;
  687.           yySynAttribute.Scan.U_1.V_6.Expr = Rules_MakePrioAlternativeNode(yyAttributeStack->A[yyStackPtr + 3].Scan.Position, yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_6.Expr, yyAttributeStack->A[yyStackPtr + 4].Scan.U_1.V_6.Expr, yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_6.HasPrio, yyAttributeStack->A[yyStackPtr + 2].Scan.Position, yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_6.U_1.V_1.PriSym, yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_6.U_1.V_1.PriSymPos);
  688.           break;
  689.         case 144:;
  690.           DEC1(yyStackPtr, 2);
  691.           yyNonterminal = 56;
  692.           yySynAttribute.Scan = yyAttributeStack->A[yyStackPtr + 2].Scan;
  693.           yySynAttribute.Scan.Mode = Scanner_RightSide;
  694.           if (yyAttributeStack->A[yyStackPtr + 1].Scan.Mode == Scanner_Empty) {
  695.             yySynAttribute.Scan.U_1.V_6.Expr = Rules_NoExpression;
  696.           } else {
  697.             yySynAttribute.Scan.U_1.V_6.Expr = yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_6.Expr;
  698.           }
  699.           break;
  700.         case 145:;
  701.         case 90:;
  702.           DEC1(yyStackPtr, 2);
  703.           yyNonterminal = 58;
  704.           if (yyAttributeStack->A[yyStackPtr + 2].Scan.Mode != Scanner_Empty) {
  705.             yySynAttribute.Scan.Mode = Scanner_RightSide;
  706.             yySynAttribute.Scan.U_1.V_6.Expr = Rules_MakeBinaryNode(Rules_Sequence, Positions_NoPosition, yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_6.Expr, yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_6.Expr);
  707.           } else {
  708.             yySynAttribute.Scan = yyAttributeStack->A[yyStackPtr + 1].Scan;
  709.           }
  710.           break;
  711.         case 146:;
  712.           DEC1(yyStackPtr, 0);
  713.           yyNonterminal = 58;
  714.           yySynAttribute.Scan.Mode = Scanner_Empty;
  715.           yySynAttribute.Scan.U_1.V_6.Expr = Rules_NoExpression;
  716.           break;
  717.         case 147:;
  718.           DEC1(yyStackPtr, 1);
  719.           yyNonterminal = 59;
  720.           yySynAttribute.Scan.Mode = Scanner_RightSide;
  721.           yySynAttribute.Scan.U_1.V_6.Expr = yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_6.Expr;
  722.           break;
  723.         case 148:;
  724.         case 75:;
  725.           DEC1(yyStackPtr, 2);
  726.           yyNonterminal = 59;
  727.           yySynAttribute.Scan.Mode = Scanner_RightSide;
  728.           yySynAttribute.Scan.U_1.V_6.Expr = Rules_MakeUnaryNode(Rules_Star, yyAttributeStack->A[yyStackPtr + 2].Scan.Position, yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_6.Expr);
  729.           break;
  730.         case 149:;
  731.         case 76:;
  732.           DEC1(yyStackPtr, 2);
  733.           yyNonterminal = 59;
  734.           yySynAttribute.Scan.Mode = Scanner_RightSide;
  735.           yySynAttribute.Scan.U_1.V_6.Expr = Rules_MakeUnaryNode(Rules_Plus, yyAttributeStack->A[yyStackPtr + 2].Scan.Position, yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_6.Expr);
  736.           break;
  737.         case 150:;
  738.         case 91:;
  739.           DEC1(yyStackPtr, 3);
  740.           yyNonterminal = 59;
  741.           yySynAttribute.Scan.Mode = Scanner_RightSide;
  742.           yySynAttribute.Scan.U_1.V_6.Expr = Rules_MakeBinaryNode(Rules_Separator, yyAttributeStack->A[yyStackPtr + 2].Scan.Position, yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_6.Expr, yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_6.Expr);
  743.           break;
  744.         case 151:;
  745.         case 77:;
  746.           DEC1(yyStackPtr, 3);
  747.           yyNonterminal = 60;
  748.           yySynAttribute.Scan.Mode = Scanner_RightSide;
  749.           yySynAttribute.Scan.U_1.V_6.Expr = Rules_MakeBracketNode(Rules_Optional, yyAttributeStack->A[yyStackPtr + 1].Scan.Position, yyAttributeStack->A[yyStackPtr + 3].Scan.Position, yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_6.Expr);
  750.           break;
  751.         case 152:;
  752.         case 78:;
  753.           DEC1(yyStackPtr, 3);
  754.           yyNonterminal = 60;
  755.           yySynAttribute.Scan.Mode = Scanner_RightSide;
  756.           yySynAttribute.Scan.U_1.V_6.Expr = Rules_MakeBracketNode(Rules_Bracket, yyAttributeStack->A[yyStackPtr + 1].Scan.Position, yyAttributeStack->A[yyStackPtr + 3].Scan.Position, yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_6.Expr);
  757.           break;
  758.         case 153:;
  759.         case 73:;
  760.           DEC1(yyStackPtr, 1);
  761.           yyNonterminal = 60;
  762.           yySynAttribute.Scan.Mode = Scanner_RightSide;
  763.           yySynAttribute.Scan.U_1.V_6.Expr = Rules_MakeLeafNode(yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_4.Sym, yyAttributeStack->A[yyStackPtr + 1].Scan.Position);
  764.           break;
  765.         case 154:;
  766.         case 74:;
  767.           DEC1(yyStackPtr, 1);
  768.           yyNonterminal = 60;
  769.           yySynAttribute.Scan.Mode = Scanner_RightSide;
  770.           yySynAttribute.Scan.U_1.V_6.Expr = Rules_MakeLeafNode(yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_4.Sym, yyAttributeStack->A[yyStackPtr + 1].Scan.Position);
  771.           break;
  772.         case 155:;
  773.         case 72:;
  774.           DEC1(yyStackPtr, 1);
  775.           yyNonterminal = 60;
  776.           yySynAttribute.Scan.Mode = Scanner_RightSide;
  777.           yySynAttribute.Scan.U_1.V_6.Expr = Rules_MakeActionNode(yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_3.Act, yyAttributeStack->A[yyStackPtr + 1].Scan.Position);
  778.           break;
  779.         case 156:;
  780.         case 92:;
  781.           DEC1(yyStackPtr, 3);
  782.           yyNonterminal = 61;
  783.           yySynAttribute.Scan.Mode = Scanner_RightSide;
  784.           yySynAttribute.Scan.U_1.V_6.Expr = Rules_MakeBinaryNode(Rules_Alternative, yyAttributeStack->A[yyStackPtr + 2].Scan.Position, yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_6.Expr, yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_6.Expr);
  785.           break;
  786.         case 157:;
  787.           DEC1(yyStackPtr, 1);
  788.           yyNonterminal = 61;
  789.           yySynAttribute.Scan.Mode = Scanner_RightSide;
  790.           if (yyAttributeStack->A[yyStackPtr + 1].Scan.Mode == Scanner_Empty) {
  791.             yySynAttribute.Scan.U_1.V_6.Expr = Rules_NoExpression;
  792.           } else {
  793.             yySynAttribute.Scan.U_1.V_6.Expr = yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_6.Expr;
  794.           }
  795.           break;
  796.         case 158:;
  797.         case 63:;
  798.           DEC1(yyStackPtr, 2);
  799.           yyNonterminal = 31;
  800.           yySynAttribute.Scan.Mode = Scanner_Comment;
  801.           if (Lists_IsEmpty(yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_1.Comm)) {
  802.             yySynAttribute.Scan.Position = yyAttributeStack->A[yyStackPtr + 2].Scan.Position;
  803.             yySynAttribute.Scan.U_1.V_1.Comm = yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_1.Comm;
  804.           } else {
  805.             Lists_Append(&yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_1.Comm, EndOfLine);
  806.             while (!Lists_IsEmpty(yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_1.Comm)) {
  807.               Lists_Append(&yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_1.Comm, Lists_Head(yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_1.Comm));
  808.               Lists_Tail(&yyAttributeStack->A[yyStackPtr + 2].Scan.U_1.V_1.Comm);
  809.             }
  810.             yySynAttribute.Scan.Position = yyAttributeStack->A[yyStackPtr + 1].Scan.Position;
  811.             yySynAttribute.Scan.U_1.V_1.Comm = yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_1.Comm;
  812.           }
  813.           break;
  814.         case 159:;
  815.           DEC1(yyStackPtr, 0);
  816.           yyNonterminal = 31;
  817.           yySynAttribute.Scan.Mode = Scanner_Comment;
  818.           yySynAttribute.Scan.Position = Positions_NoPosition;
  819.           Lists_MakeList(&yySynAttribute.Scan.U_1.V_1.Comm);
  820.           break;
  821.         }
  822.         yyNCombPtr = (yyNCombTypePtr)((LONGCARD)yyNBasePtr.A[yyStateStack->A[yyStackPtr]] + yyNonterminal * sizeof(yyNCombType));
  823.         yyState = *yyNCombPtr;
  824.         INC(yyStackPtr);
  825.         yyAttributeStack->A[yyStackPtr] = yySynAttribute;
  826.         if (yyState < yyFirstFinalState) {
  827.           goto EXIT_3;
  828.         }
  829.       } EXIT_3:;
  830.     } else {
  831.       INC(yyStackPtr);
  832.       yyAttributeStack->A[yyStackPtr].Scan = Scanner_Attribute;
  833.       yyTerminal = Scanner_GetToken();
  834.       yyIsRepairing = FALSE;
  835.     }
  836.   } EXIT_1:;
  837. }
  838.  
  839. static void ErrorRecovery
  840. # ifdef __STDC__
  841. (yySymbolRange *Terminal, yyStackType StateStack, LONGINT StackSize, LONGINT StackPtr)
  842. # else
  843. (Terminal, StateStack, StackSize, StackPtr)
  844. yySymbolRange *Terminal;
  845. yyStackType StateStack;
  846. LONGINT StackSize;
  847. LONGINT StackPtr;
  848. # endif
  849. {
  850.   BOOLEAN TokensSkipped;
  851.   Sets_tSet ContinueSet;
  852.   Sets_tSet RestartSet;
  853.   yySymbolRange Token;
  854.   struct S_18 TokenArray;
  855.   Strings_tString TokenString;
  856.   Strings_tString ContinueString;
  857.  
  858.   Errors_ErrorMessage((LONGCARD)Errors_SyntaxError, (LONGCARD)Errors_Error, Scanner_Attribute.Position);
  859.   Sets_MakeSet(&ContinueSet, (LONGCARD)yyLastTerminal);
  860.   ComputeContinuation(StateStack, StackSize, StackPtr, &ContinueSet);
  861.   Strings_AssignEmpty(&ContinueString);
  862.   {
  863.     yySymbolRange B_3 = Sets_Minimum(&ContinueSet), B_4 = Sets_Maximum(&ContinueSet);
  864.  
  865.     if (B_3 <= B_4)
  866.       for (Token = B_3;; Token += 1) {
  867.         if (Sets_IsElement((LONGCARD)Token, &ContinueSet)) {
  868.           Parser_TokenName((LONGCARD)Token, TokenArray.A, 128L);
  869.           Strings_ArrayToString(TokenArray.A, 128L, &TokenString);
  870.           if (Strings_Length(&ContinueString) + Strings_Length(&TokenString) + 1 <= Strings_cMaxStrLength) {
  871.             Strings_Concatenate(&ContinueString, &TokenString);
  872.             Strings_Append(&ContinueString, ' ');
  873.           }
  874.         }
  875.         if (Token >= B_4) break;
  876.       }
  877.   }
  878.   Errors_ErrorMessageI((LONGCARD)Errors_ExpectedTokens, (LONGCARD)Errors_Information, Scanner_Attribute.Position, (LONGCARD)Errors_String, ADR(ContinueString));
  879.   Sets_ReleaseSet(&ContinueSet);
  880.   Sets_MakeSet(&RestartSet, (LONGCARD)yyLastTerminal);
  881.   ComputeRestartPoints(StateStack, StackSize, StackPtr, &RestartSet);
  882.   TokensSkipped = FALSE;
  883.   while (!Sets_IsElement((LONGCARD)(*Terminal), &RestartSet)) {
  884.     *Terminal = Scanner_GetToken();
  885.     TokensSkipped = TRUE;
  886.   }
  887.   Sets_ReleaseSet(&RestartSet);
  888.   if (TokensSkipped) {
  889.     Errors_ErrorMessage((LONGCARD)Errors_RestartPoint, (LONGCARD)Errors_Information, Scanner_Attribute.Position);
  890.   }
  891. }
  892.  
  893. static void ComputeContinuation
  894. # ifdef __STDC__
  895. (yyStackType Stack, LONGINT StackSize, LONGINT StackPtr, Sets_tSet *ContinueSet)
  896. # else
  897. (Stack, StackSize, StackPtr, ContinueSet)
  898. yyStackType Stack;
  899. LONGINT StackSize;
  900. LONGINT StackPtr;
  901. Sets_tSet *ContinueSet;
  902. # endif
  903. {
  904.   yySymbolRange Terminal;
  905.  
  906.   Sets_AssignEmpty(ContinueSet);
  907.   for (Terminal = yyFirstTerminal; Terminal <= yyLastTerminal; Terminal += 1) {
  908.     if (IsContinuation(Terminal, Stack, StackSize, StackPtr)) {
  909.       Sets_Include(ContinueSet, (LONGCARD)Terminal);
  910.     }
  911.   }
  912. }
  913.  
  914. static BOOLEAN IsContinuation
  915. # ifdef __STDC__
  916. (yySymbolRange Terminal, yyStackType ParseStack, LONGINT StackSize, LONGINT StackPtr)
  917. # else
  918. (Terminal, ParseStack, StackSize, StackPtr)
  919. yySymbolRange Terminal;
  920. yyStackType ParseStack;
  921. LONGINT StackSize;
  922. LONGINT StackPtr;
  923. # endif
  924. {
  925.   LONGINT State;
  926.   yySymbolRange Nonterminal;
  927.   yyStackType Stack;
  928.  
  929.   DynArray_MakeArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  930.   {
  931.     LONGINT B_5 = 0, B_6 = StackPtr;
  932.  
  933.     if (B_5 <= B_6)
  934.       for (State = B_5;; State += 1) {
  935.         Stack->A[State] = ParseStack->A[State];
  936.         if (State >= B_6) break;
  937.       }
  938.   }
  939.   State = Stack->A[StackPtr];
  940.   for (;;) {
  941.     Stack->A[StackPtr] = State;
  942.     State = Next((yyStateRange)State, Terminal);
  943.     if (State == yyNoState) {
  944.       DynArray_ReleaseArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  945.       return FALSE;
  946.     }
  947.     if (State <= yyLastReadTermState) {
  948.       DynArray_ReleaseArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  949.       return TRUE;
  950.     }
  951.     for (;;) {
  952.       if (State == yyStopState) {
  953.         DynArray_ReleaseArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  954.         return TRUE;
  955.       } else {
  956.         DEC1(StackPtr, yyLength.A[State - 97]);
  957.         Nonterminal = yyLeftHandSide.A[State - 97];
  958.       }
  959.       State = Next(Stack->A[StackPtr], Nonterminal);
  960.       if (StackPtr >= StackSize) {
  961.         DynArray_ExtendArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  962.       }
  963.       INC(StackPtr);
  964.       if (State < yyFirstFinalState) {
  965.         goto EXIT_5;
  966.       }
  967.       State = yyFinalToProd.A[State - 63];
  968.     } EXIT_5:;
  969.   } EXIT_4:;
  970. }
  971.  
  972. static void ComputeRestartPoints
  973. # ifdef __STDC__
  974. (yyStackType ParseStack, LONGINT StackSize, LONGINT StackPtr, Sets_tSet *RestartSet)
  975. # else
  976. (ParseStack, StackSize, StackPtr, RestartSet)
  977. yyStackType ParseStack;
  978. LONGINT StackSize;
  979. LONGINT StackPtr;
  980. Sets_tSet *RestartSet;
  981. # endif
  982. {
  983.   yyStackType Stack;
  984.   LONGINT State;
  985.   yySymbolRange Nonterminal;
  986.   Sets_tSet ContinueSet;
  987.  
  988.   DynArray_MakeArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  989.   {
  990.     LONGINT B_7 = 0, B_8 = StackPtr;
  991.  
  992.     if (B_7 <= B_8)
  993.       for (State = B_7;; State += 1) {
  994.         Stack->A[State] = ParseStack->A[State];
  995.         if (State >= B_8) break;
  996.       }
  997.   }
  998.   Sets_MakeSet(&ContinueSet, (LONGCARD)yyLastTerminal);
  999.   Sets_AssignEmpty(RestartSet);
  1000.   State = Stack->A[StackPtr];
  1001.   for (;;) {
  1002.     if (StackPtr >= StackSize) {
  1003.       DynArray_ExtendArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1004.     }
  1005.     Stack->A[StackPtr] = State;
  1006.     ComputeContinuation(Stack, StackSize, StackPtr, &ContinueSet);
  1007.     Sets_Union(RestartSet, ContinueSet);
  1008.     State = Next((yyStateRange)State, yyContinuation.A[State]);
  1009.     if (State >= yyFirstFinalState) {
  1010.       if (State <= yyLastReadTermState) {
  1011.         INC(StackPtr);
  1012.         State = yyFinalToProd.A[State - 63];
  1013.       }
  1014.       for (;;) {
  1015.         if (State == yyStopState) {
  1016.           DynArray_ReleaseArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1017.           Sets_ReleaseSet(&ContinueSet);
  1018.           return;
  1019.         } else {
  1020.           DEC1(StackPtr, yyLength.A[State - 97]);
  1021.           Nonterminal = yyLeftHandSide.A[State - 97];
  1022.         }
  1023.         State = Next(Stack->A[StackPtr], Nonterminal);
  1024.         INC(StackPtr);
  1025.         if (State < yyFirstFinalState) {
  1026.           goto EXIT_7;
  1027.         }
  1028.         State = yyFinalToProd.A[State - 63];
  1029.       } EXIT_7:;
  1030.     } else {
  1031.       INC(StackPtr);
  1032.     }
  1033.   } EXIT_6:;
  1034. }
  1035.  
  1036. static yyStateRange Next
  1037. # ifdef __STDC__
  1038. (yyStateRange State, yySymbolRange Symbol)
  1039. # else
  1040. (State, Symbol)
  1041. yyStateRange State;
  1042. yySymbolRange Symbol;
  1043. # endif
  1044. {
  1045.   yyTCombTypePtr TCombPtr;
  1046.   yyNCombTypePtr NCombPtr;
  1047.  
  1048.   if (Symbol <= yyLastTerminal) {
  1049.     for (;;) {
  1050.       TCombPtr = (yyTCombTypePtr)((LONGCARD)yyTBasePtr.A[State] + Symbol * sizeof(yyTCombType));
  1051.       if (TCombPtr->Check != State) {
  1052.         State = yyDefault.A[State];
  1053.         if (State == yyNoState) {
  1054.           return yyNoState;
  1055.         }
  1056.       } else {
  1057.         return TCombPtr->Next;
  1058.       }
  1059.     } EXIT_8:;
  1060.   } else {
  1061.     NCombPtr = (yyNCombTypePtr)((LONGCARD)yyNBasePtr.A[State] + Symbol * sizeof(yyNCombType));
  1062.     return *NCombPtr;
  1063.   }
  1064. }
  1065.  
  1066. static void yyGetTables
  1067. # ifdef __STDC__
  1068. ()
  1069. # else
  1070. ()
  1071. # endif
  1072. {
  1073.   CARDINAL BlockSize, j, n;
  1074.   yyStateRange State;
  1075.   struct S_19 TBase;
  1076.   struct S_20 NBase;
  1077.  
  1078.   BlockSize = 64000 / sizeof(yyTCombType);
  1079.   yyTableFile = OpenInput(Parser_ParsTabName.A, 129L);
  1080.   yyErrorCheck((LONGINT)Errors_OpenParseTable, yyTableFile);
  1081.   if (yyGetTable(ADR(TBase)) / sizeof(yyTCombRange) - 1 != yyLastReadState || yyGetTable(ADR(NBase)) / sizeof(yyNCombRange) - 1 != yyLastReadState || yyGetTable(ADR(yyDefault)) / sizeof(yyReadRange) - 1 != yyLastReadState || yyGetTable(ADR(yyNComb)) / sizeof(yyNCombType) != yyNTableMax - yyLastTerminal || yyGetTable(ADR(yyLength)) / sizeof(yyTableElmt) - 1 != yyLastReduceState - yyFirstReduceState || yyGetTable(ADR(yyLeftHandSide)) / sizeof(yySymbolRange) - 1 != yyLastReduceState - yyFirstReduceState || yyGetTable(ADR(yyContinuation)) / sizeof(yySymbolRange) - 1 != yyLastReadState || yyGetTable(ADR(yyFinalToProd)) / sizeof(yyReduceRange) - 1 != yyLastReadNontermState - yyFirstReadTermState) {
  1082.     Errors_ErrorMessage((LONGCARD)Errors_WrongParseTable, (LONGCARD)Errors_Fatal, Positions_NoPosition);
  1083.   }
  1084.   n = 0;
  1085.   j = 0;
  1086.   while (j <= yyTableMax) {
  1087.     INC1(n, yyGetTable(ADR(yyTComb.A[j])) / sizeof(yyTCombType));
  1088.     INC1(j, BlockSize);
  1089.   }
  1090.   if (n != yyTableMax + 1) {
  1091.     Errors_ErrorMessage((LONGCARD)Errors_WrongParseTable, (LONGCARD)Errors_Fatal, Positions_NoPosition);
  1092.   }
  1093.   Close(yyTableFile);
  1094.   for (State = 1; State <= yyLastReadState; State += 1) {
  1095.     yyTBasePtr.A[State] = (yyTCombTypePtr)ADR(yyTComb.A[TBase.A[State]]);
  1096.   }
  1097.   for (State = 1; State <= yyLastReadState; State += 1) {
  1098.     yyNBasePtr.A[State] = (yyNCombTypePtr)ADR(yyNComb.A[NBase.A[State] - 31]);
  1099.   }
  1100. }
  1101.  
  1102. static CARDINAL yyGetTable
  1103. # ifdef __STDC__
  1104. (ADDRESS Address)
  1105. # else
  1106. (Address)
  1107. ADDRESS Address;
  1108. # endif
  1109. {
  1110.   INTEGER N;
  1111.   yyTableElmt Length;
  1112.  
  1113.   N = Read(yyTableFile, ADR(Length), (LONGCARD)sizeof(yyTableElmt));
  1114.   yyErrorCheck((LONGINT)Errors_ReadParseTable, N);
  1115.   N = Read(yyTableFile, Address, (LONGCARD)Length);
  1116.   yyErrorCheck((LONGINT)Errors_ReadParseTable, N);
  1117.   return Length;
  1118. }
  1119.  
  1120. static void yyErrorCheck
  1121. # ifdef __STDC__
  1122. (INTEGER ErrorCode, INTEGER Info)
  1123. # else
  1124. (ErrorCode, Info)
  1125. INTEGER ErrorCode;
  1126. INTEGER Info;
  1127. # endif
  1128. {
  1129.   INTEGER ErrNo;
  1130.  
  1131.   if (Info < 0) {
  1132.     ErrNo = ErrNum();
  1133.     Errors_ErrorMessageI((LONGCARD)ErrorCode, (LONGCARD)Errors_Fatal, Positions_NoPosition, (LONGCARD)Errors_Integer, ADR(ErrNo));
  1134.   }
  1135. }
  1136.  
  1137. static void BeginParser
  1138. # ifdef __STDC__
  1139. ()
  1140. # else
  1141. ()
  1142. # endif
  1143. {
  1144.   Strings_AssignEmpty(&EndOfLineString);
  1145.   Strings_Append(&EndOfLineString, cEol);
  1146.   EndOfLine = (ADDRESS)StringMem_PutString(&EndOfLineString);
  1147.   if (!yyIsInitialized) {
  1148.     yyIsInitialized = TRUE;
  1149.     yyGetTables();
  1150.   }
  1151. }
  1152.  
  1153. void Parser_CloseParser
  1154. # ifdef __STDC__
  1155. ()
  1156. # else
  1157. ()
  1158. # endif
  1159. {
  1160. }
  1161.  
  1162. void BEGIN_Parser()
  1163. {
  1164.   static BOOLEAN has_been_called = FALSE;
  1165.  
  1166.   if (!has_been_called) {
  1167.     has_been_called = TRUE;
  1168.  
  1169.     BEGIN_Scanner();
  1170.     BEGIN_Positions();
  1171.     BEGIN_Errors();
  1172.     BEGIN_Strings();
  1173.     BEGIN_DynArray();
  1174.     BEGIN_Sets();
  1175.     BEGIN_System();
  1176.     BEGIN_Actions();
  1177.     BEGIN_Errors();
  1178.     BEGIN_Lists();
  1179.     BEGIN_Oper();
  1180.     BEGIN_Scanner();
  1181.     BEGIN_Positions();
  1182.     BEGIN_Strings();
  1183.     BEGIN_StringMem();
  1184.     BEGIN_Idents();
  1185.     BEGIN_TokenTab();
  1186.     BEGIN_Tokens();
  1187.     BEGIN_Rules();
  1188.  
  1189.     yyIsInitialized = FALSE;
  1190.     (void)strncpy((char *)Parser_ParsTabName.A, "Parser.Tab", sizeof(Parser_ParsTabName.A));
  1191.   }
  1192. }
  1193.